import os
import sys
import threading
import time
from dotenv import load_dotenv
from flask import Flask, request, jsonify, render_template, redirect, url_for
from flask_cors import CORS

# 添加当前目录到Python路径，解决相对导入问题
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

# 尝试不同的导入方式
try:
    # 优先使用相对导入
    from .db_config import get_db
    from .optimized_data_processor import OptimizedDataProcessor as DataProcessor
    from .llm_wrapper import LLMWrapper
except ImportError:
    # 如果相对导入失败，尝试绝对导入
    from backend.db_config import get_db
    from backend.optimized_data_processor import OptimizedDataProcessor as DataProcessor
    from backend.llm_wrapper import LLMWrapper

# 加载环境变量
load_dotenv()

# 创建Flask应用，使用frontend目录下的静态文件和模板
app = Flask(__name__, 
            template_folder='../frontend/templates', 
            static_folder='../frontend/static')

# 启用CORS
CORS(app)

# 设置配置
app.config['SECRET_KEY'] = os.urandom(24)
app.config['DEBUG'] = os.getenv('FLASK_DEBUG', 'True').lower() == 'true'

# 初始化LLM包装器
global_llm_wrapper = LLMWrapper()

# 全局变量用于存储最新的知识图谱数据
latest_graph_data = None
last_reload_time = None

def auto_reload_data():
    """定时自动重新加载数据的函数"""
    global latest_graph_data, last_reload_time
    
    while True:
        try:
            # 每隔30分钟自动重新加载一次数据
            time.sleep(30 * 60)  # 30分钟 = 30 * 60秒
            
            # 创建数据库会话
            db = next(get_db())
            
            try:
                # 初始化数据处理器
                data_processor = DataProcessor(db)
                
                # 重新构建知识图谱数据
                latest_graph_data = data_processor.build_knowledge_graph()
                last_reload_time = time.time()
                
                print(f"[自动重新加载] 数据重新加载成功，节点数: {len(latest_graph_data['nodes'])}, 关系数: {len(latest_graph_data['edges'])}")
            finally:
                # 关闭数据库会话
                db.close()
        except Exception as e:
            print(f"[自动重新加载] 数据重新加载失败: {e}")

# 启动自动重新加载线程
auto_reload_thread = threading.Thread(target=auto_reload_data, daemon=True)
auto_reload_thread.start()

@app.route('/')
def index():
    """首页路由"""
    return render_template('index.html')

@app.route('/test')
def test_page():
    """测试页面路由"""
    return render_template('test_page.html')

@app.route('/api/query', methods=['POST'])
def query():
    """处理用户查询的主要API端点"""
    global latest_graph_data
    
    try:
        # 获取请求数据
        data = request.get_json()
        if not data or 'query' not in data:
            return jsonify({'error': '缺少查询参数'}), 400
        
        user_query = data['query']
        
        # 使用最新的数据或者重新构建数据
        if latest_graph_data is not None:
            graph_data = latest_graph_data
        else:
            # 创建数据库会话
            db = next(get_db())
            
            try:
                # 初始化数据处理器
                data_processor = DataProcessor(db)
                
                # 构建知识图谱数据
                graph_data = data_processor.build_knowledge_graph()
            finally:
                # 关闭数据库会话
                db.close()
        
        # 初始化LLM包装器（如果尚未初始化）
        llm_wrapper = global_llm_wrapper
        
        # 处理用户查询
        # 创建数据库会话用于查询处理
        db = next(get_db())
        try:
            data_processor = DataProcessor(db)
            result = data_processor.process_query(user_query, graph_data, llm_wrapper)
        finally:
            db.close()
        
        # 包装结果
        response_data = {
            'success': True,
            'data': result
        }
        
        return jsonify(response_data)
    except Exception as e:
        return jsonify({'error': f'处理查询时发生错误: {str(e)}'}), 500

@app.route('/api/knowledge-graph', methods=['GET'])
def get_knowledge_graph():
    """获取知识图谱数据"""
    global latest_graph_data
    
    try:
        # 使用最新的数据或者重新构建数据
        if latest_graph_data is not None:
            graph_data = latest_graph_data
        else:
            # 创建数据库会话
            db = next(get_db())
            
            try:
                # 初始化数据处理器
                data_processor = DataProcessor(db)
                
                # 构建知识图谱
                graph_data = data_processor.build_knowledge_graph()
            finally:
                # 关闭数据库会话
                db.close()
        
        return jsonify({
            'success': True,
            'data': graph_data
        })
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/search', methods=['GET'])
def search_resources():
    """搜索资源节点"""
    try:
        # 获取搜索关键词
        keyword = request.args.get('q', '')  # 兼容test_all_features.py中的参数名
        
        if not keyword:
            # 如果q参数为空，尝试使用keyword参数
            keyword = request.args.get('keyword', '')
            
        if not keyword:
            return jsonify({
                'success': False,
                'error': '搜索关键词不能为空'
            }), 400
        
        # 创建数据库会话
        db = next(get_db())
        
        try:
            # 初始化数据处理器
            data_processor = DataProcessor(db)
            
            # 搜索资源
            results = data_processor.search_resources_by_keyword(keyword)
            
            return jsonify({
                'success': True,
                'results': results,
                'count': len(results)
            })
        finally:
            # 关闭数据库会话
            db.close()
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/related-resources', methods=['GET'])
def get_related_resources():
    """获取相关资源节点"""
    try:
        # 获取资源ID和深度参数
        resource_id = request.args.get('id', '')
        depth = int(request.args.get('depth', 1))
        
        if not resource_id:
            return jsonify({
                'success': False,
                'error': '资源ID不能为空'
            }), 400
        
        # 创建数据库会话
        db = next(get_db())
        
        try:
            # 初始化数据处理器
            data_processor = DataProcessor(db)
            
            # 查找相关资源
            related_resources = data_processor.find_related_resources(resource_id, depth)
            
            return jsonify({
                'success': True,
                'related_resources': related_resources,
                'count': len(related_resources)
            })
        finally:
            # 关闭数据库会话
            db.close()
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/resource/<resource_id>', methods=['GET'])
def get_resource_by_id(resource_id):
    """根据资源ID获取资源详情"""
    try:
        if not resource_id:
            return jsonify({
                'success': False,
                'error': '资源ID不能为空'
            }), 400
        
        # 创建数据库会话
        db = next(get_db())
        
        try:
            # 初始化数据处理器
            data_processor = DataProcessor(db)
            
            # 获取资源详情
            resource = data_processor.get_resource_by_id(resource_id)
            
            if not resource:
                return jsonify({
                    'success': False,
                    'error': '未找到指定ID的资源'
                }), 404
            
            return jsonify({
                'success': True,
                'resource': resource
            })
        finally:
            # 关闭数据库会话
            db.close()
    except Exception as e:
        return jsonify({
            'success': False,
            'error': str(e)
        }), 500

@app.route('/api/health', methods=['GET'])
def health_check():
    """健康检查接口"""
    return jsonify({
        'success': True,
        'status': 'running',
        'version': '1.0.0'
    })

@app.route('/api/reload-data', methods=['POST'])
def reload_data():
    """重新加载数据库中的数据并重建知识图谱"""
    global latest_graph_data, last_reload_time
    
    try:
        # 创建数据库会话
        db = next(get_db())
        
        try:
            # 初始化数据处理器
            data_processor = DataProcessor(db)
            
            # 重新构建知识图谱数据
            graph_data = data_processor.build_knowledge_graph()
            
            # 更新全局变量
            latest_graph_data = graph_data
            last_reload_time = time.time()
            
            # 返回成功响应
            return jsonify({
                "success": True,
                "message": "数据重新加载成功",
                "nodes_count": len(graph_data['nodes']),
                "edges_count": len(graph_data['edges'])
            })
        finally:
            # 关闭数据库会话
            db.close()
    except Exception as e:
        # 返回错误响应
        return jsonify({
            "success": False,
            "error": str(e)
        }), 500

if __name__ == '__main__':
    # 运行Flask应用
    app.run(
        host=os.getenv('FLASK_RUN_HOST', '0.0.0.0'),
        port=int(os.getenv('FLASK_RUN_PORT', 5000)),
        debug=app.config['DEBUG']
    )